home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / DJGPP / BNU22SR1.ZIP / src / binutils.2 / gprof / i386.c < prev    next >
C/C++ Source or Header  |  1993-05-30  |  4KB  |  144 lines
  1. /*
  2.  * Copyright (c) 1983 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms are permitted
  6.  * provided that: (1) source distributions retain this entire copyright
  7.  * notice and comment, and (2) distributions including binaries display
  8.  * the following acknowledgement:  ``This product includes software
  9.  * developed by the University of California, Berkeley and its contributors''
  10.  * in the documentation or other materials provided with the distribution
  11.  * and in all advertising materials mentioning features or use of this
  12.  * software. Neither the name of the University nor the names of its
  13.  * contributors may be used to endorse or promote products derived
  14.  * from this software without specific prior written permission.
  15.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18.  */
  19.  
  20. #ifndef lint
  21. static char sccsid[] = "@(#)tahoe.c    1.5 (Berkeley) 6/1/90";
  22. #endif /* not lint */
  23.  
  24. #include    "gprof.h"
  25.  
  26.     /*
  27.      *    a namelist entry to be the child of indirect callf
  28.      */
  29. nltype    indirectchild = {
  30.     "(*)" ,                /* the name */
  31.     (unsigned long) 0 ,        /* the pc entry point */
  32.     (unsigned long) 0 ,        /* entry point aligned to histogram */
  33.     (double) 0.0 ,            /* ticks in this routine */
  34.     (double) 0.0 ,            /* cumulative ticks in children */
  35.     (long) 0 ,            /* how many times called */
  36.     (long) 0 ,            /* how many calls to self */
  37.     (double) 1.0 ,            /* propagation fraction */
  38.     (double) 0.0 ,            /* self propagation time */
  39.     (double) 0.0 ,            /* child propagation time */
  40.     (bool) 0 ,            /* print flag */
  41.     (int) 0 ,            /* index in the graph list */
  42.     (int) 0 ,             /* graph call chain top-sort order */
  43.     (int) 0 ,            /* internal number of cycle on */
  44.     (struct nl *) &indirectchild ,    /* pointer to head of cycle */
  45.     (struct nl *) 0 ,        /* pointer to next member of cycle */
  46.     (arctype *) 0 ,            /* list of caller arcs */
  47.     (arctype *) 0             /* list of callee arcs */
  48.     };
  49.  
  50. #ifdef    __STDC__
  51. int
  52. iscall (unsigned char *ip)
  53. #else
  54. int iscall(ip)
  55.     unsigned char *ip;
  56. #endif    /* __STDC__ */
  57. {
  58.   if (*ip == 0xeb || *ip == 0x9a) 
  59.     return 1;
  60.   return 0;
  61. }
  62.  
  63. findcall( parentp , p_lowpc , p_highpc )
  64.     nltype        *parentp;
  65.     unsigned long    p_lowpc;
  66.     unsigned long    p_highpc;
  67. {
  68.     unsigned char    *instructp;
  69.     long        length;
  70.     nltype        *childp;
  71.     unsigned long    destpc;
  72.  
  73.     if ( textspace == 0 ) {
  74.     return;
  75.     }
  76.     if ( p_lowpc < s_lowpc ) {
  77.     p_lowpc = s_lowpc;
  78.     }
  79.     if ( p_highpc > s_highpc ) {
  80.     p_highpc = s_highpc;
  81.     }
  82. #   ifdef DEBUG
  83.     if ( debug & CALLDEBUG ) {
  84.         printf( "[findcall] %s: 0x%x to 0x%x\n" ,
  85.             parentp -> name , p_lowpc , p_highpc );
  86.     }
  87. #   endif DEBUG
  88.     for (   instructp = textspace + p_lowpc ;
  89.         instructp < textspace + p_highpc ;
  90.         instructp += length ) {
  91.     length = 1;
  92.     if ( iscall (instructp) ) {
  93. #        ifdef DEBUG
  94.       if ( debug & CALLDEBUG ) {
  95.         printf( "[findcall]\t0x%x:callf" , instructp - textspace );
  96.       }
  97. #        endif DEBUG
  98.       length = 4;
  99.       /*
  100.        *    regular pc relative addressing
  101.        *    check that this is the address of 
  102.        *    a function.
  103.        */
  104.       destpc = ( (unsigned long)instructp + 5 - (unsigned long) textspace);
  105.       if ( destpc >= s_lowpc && destpc <= s_highpc ) {
  106.         childp = nllookup( destpc );
  107. #            ifdef DEBUG
  108.         if ( debug & CALLDEBUG ) {
  109.           printf( "[findcall]\tdestpc 0x%x" , destpc );
  110.           printf( " childp->name %s" , childp -> name );
  111.           printf( " childp->value 0x%x\n" ,
  112.              childp -> value );
  113.         }
  114. #            endif DEBUG
  115.         if ( childp -> value == destpc ) {
  116.           /*
  117.            *    a hit
  118.            */
  119.           addarc( parentp , childp , (long) 0 );
  120.           length += 4;    /* constant lengths */
  121.           continue;
  122.         }
  123.         goto botched;
  124.       }
  125.       /*
  126.        *    else:
  127.        *    it looked like a callf,
  128.        *    but it wasn't to anywhere.
  129.        */
  130.     botched:
  131.       /*
  132.        *    something funny going on.
  133.        */
  134. #            ifdef DEBUG
  135.       if ( debug & CALLDEBUG ) {
  136.         printf( "[findcall]\tbut it's a botch\n" );
  137.       }
  138. #            endif DEBUG
  139.       length = 1;
  140.       continue;
  141.     }
  142.       }
  143.   }
  144.